{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Configurations for Colab"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-09-06T05:38:38.161660200Z",
     "start_time": "2023-09-06T05:38:38.094662Z"
    }
   },
   "outputs": [],
   "source": [
    "import sys\n",
    "IN_COLAB = \"google.colab\" in sys.modules\n",
    "\n",
    "if IN_COLAB:\n",
    "    !apt install python-opengl\n",
    "    !apt install ffmpeg\n",
    "    !apt install xvfb\n",
    "    !pip install PyVirtualDisplay==3.0\n",
    "    !pip install gymnasium==0.28.1\n",
    "    from pyvirtualdisplay import Display\n",
    "    \n",
    "    # Start virtual display\n",
    "    dis = Display(visible=0, size=(400, 400))\n",
    "    dis.start()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 07. N-Step Learning\n",
    "\n",
    "[R. S. Sutton, \"Learning to predict by the methods of temporal differences.\" Machine learning, 3(1):9–44, 1988.](http://incompleteideas.net/papers/sutton-88-with-erratum.pdf)\n",
    "\n",
    "Q-learning accumulates a single reward and then uses the greedy action at the next step to bootstrap. Alternatively, forward-view multi-step targets can be used (Sutton 1988). We call it Truncated N-Step Return\n",
    "from a given state $S_t$. It is defined as,\n",
    "\n",
    "$$\n",
    "R^{(n)}_t = \\sum_{k=0}^{n-1} \\gamma_t^{(k)} R_{t+k+1}.\n",
    "$$\n",
    "\n",
    "A multi-step variant of DQN is then defined by minimizing the alternative loss,\n",
    "\n",
    "$$\n",
    "(R^{(n)}_t + \\gamma^{(n)}_t \\max_{a'} q_{\\theta}^{-}\n",
    "(S_{t+n}, a')\n",
    "- q_{\\theta}(S_t, A_t))^2.\n",
    "$$\n",
    "\n",
    "Multi-step targets with suitably tuned $n$ often lead to faster learning (Sutton and Barto 1998)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-09-06T05:38:38.166660900Z",
     "start_time": "2023-09-06T05:38:38.112661100Z"
    }
   },
   "outputs": [],
   "source": [
    "import os\n",
    "from collections import deque\n",
    "from typing import Deque, Dict, List, Tuple\n",
    "\n",
    "import gymnasium as gym\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torch.optim as optim\n",
    "from IPython.display import clear_output"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Replay buffer for N-step learning\n",
    "\n",
    "There are a little bit changes in Replay buffer for N-step learning. First, we use `deque` to store the most recent n-step transitions.\n",
    "\n",
    "```python\n",
    "    self.n_step_buffer = deque(maxlen=n_step)\n",
    "```\n",
    "\n",
    "You can see it doesn't actually store a transition in the buffer, unless `n_step_buffer` is full.\n",
    "\n",
    "```\n",
    "    # in store method\n",
    "    if len(self.n_step_buffer) < self.n_step:\n",
    "        return ()\n",
    "```\n",
    "\n",
    "When the length of `n_step_buffer` becomes equal to N, it eventually stores the N-step transition, which is calculated by `_get_n_step_info` method.\n",
    "\n",
    "(Please see *01.dqn.ipynb* for detailed description of the basic replay buffer.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-09-06T05:38:38.166660900Z",
     "start_time": "2023-09-06T05:38:38.136662500Z"
    }
   },
   "outputs": [],
   "source": [
    "class ReplayBuffer:\n",
    "    \"\"\"A simple numpy replay buffer.\"\"\"\n",
    "\n",
    "    def __init__(\n",
    "        self, \n",
    "        obs_dim: int, \n",
    "        size: int, \n",
    "        batch_size: int = 32, \n",
    "        n_step: int = 3, \n",
    "        gamma: float = 0.99,\n",
    "    ):\n",
    "        self.obs_buf = np.zeros([size, obs_dim], dtype=np.float32)\n",
    "        self.next_obs_buf = np.zeros([size, obs_dim], dtype=np.float32)\n",
    "        self.acts_buf = np.zeros([size], dtype=np.float32)\n",
    "        self.rews_buf = np.zeros([size], dtype=np.float32)\n",
    "        self.done_buf = np.zeros(size, dtype=np.float32)\n",
    "        self.max_size, self.batch_size = size, batch_size\n",
    "        self.ptr, self.size, = 0, 0\n",
    "        \n",
    "        # for N-step Learning\n",
    "        # deque 的特性：当达到最大容量后仍在队尾插入值，则队头的值出队\n",
    "        self.n_step_buffer = deque(maxlen=n_step)\n",
    "        self.n_step = n_step\n",
    "        self.gamma = gamma\n",
    "\n",
    "    def store(\n",
    "        self, \n",
    "        obs: np.ndarray, \n",
    "        act: np.ndarray, \n",
    "        rew: float, \n",
    "        next_obs: np.ndarray, \n",
    "        done: bool\n",
    "    ) -> Tuple[np.ndarray, np.ndarray, float, np.ndarray, bool]:\n",
    "        transition = (obs, act, rew, next_obs, done)\n",
    "        self.n_step_buffer.append(transition)\n",
    "\n",
    "        # single step transition is not ready\n",
    "        if len(self.n_step_buffer) < self.n_step:\n",
    "            return ()\n",
    "        \n",
    "        # make a n-step transition\n",
    "        rew, next_obs, done = self._get_n_step_info(\n",
    "            self.n_step_buffer, self.gamma\n",
    "        )\n",
    "        obs, act = self.n_step_buffer[0][:2]\n",
    "        \n",
    "        self.obs_buf[self.ptr] = obs\n",
    "        self.next_obs_buf[self.ptr] = next_obs\n",
    "        self.acts_buf[self.ptr] = act\n",
    "        self.rews_buf[self.ptr] = rew\n",
    "        self.done_buf[self.ptr] = done\n",
    "        self.ptr = (self.ptr + 1) % self.max_size\n",
    "        self.size = min(self.size + 1, self.max_size)\n",
    "        \n",
    "        return self.n_step_buffer[0]  # 返回的是一步的 transition\n",
    "\n",
    "    def sample_batch(self) -> Dict[str, np.ndarray]:\n",
    "        indices = np.random.choice(\n",
    "            self.size, size=self.batch_size, replace=False\n",
    "        )\n",
    "\n",
    "        return dict(\n",
    "            obs=self.obs_buf[indices],\n",
    "            next_obs=self.next_obs_buf[indices],\n",
    "            acts=self.acts_buf[indices],\n",
    "            rews=self.rews_buf[indices],\n",
    "            done=self.done_buf[indices],\n",
    "            # for N-step Learning\n",
    "            indices=indices,    # 这里是保证和单步采样拿到一样的样本\n",
    "            \n",
    "            \n",
    "        )\n",
    "    \n",
    "    def sample_batch_from_idxs(\n",
    "        self, indices: np.ndarray\n",
    "    ) -> Dict[str, np.ndarray]:\n",
    "        # for N-step Learning\n",
    "        return dict(\n",
    "            obs=self.obs_buf[indices],\n",
    "            next_obs=self.next_obs_buf[indices],\n",
    "            acts=self.acts_buf[indices],\n",
    "            rews=self.rews_buf[indices],\n",
    "            done=self.done_buf[indices],\n",
    "        )\n",
    "    \n",
    "    def _get_n_step_info(\n",
    "        self, n_step_buffer: Deque, gamma: float\n",
    "    ) -> Tuple[np.int64, np.ndarray, bool]:\n",
    "        \"\"\"Return n step rew, next_obs, and done.\"\"\"\n",
    "        # info of the last transition\n",
    "        rew, next_obs, done = n_step_buffer[-1][-3:]\n",
    "\n",
    "        # 从倒数第二个开始，从后往前遍历\n",
    "        # [0] 是最旧的，[n_step - 1] 是最新的数据\n",
    "        for transition in reversed(list(n_step_buffer)[:-1]):\n",
    "            r, n_o, d = transition[-3:]  # n_o: new observation, s'\n",
    "\n",
    "            rew = r + gamma * rew * (1 - d)  # 计算这 n 步的 reward\n",
    "            next_obs, done = (n_o, d) if d else (next_obs, done)\n",
    "\n",
    "        return rew, next_obs, done\n",
    "\n",
    "    def __len__(self) -> int:\n",
    "        return self.size"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Network\n",
    "\n",
    "We are going to use a simple network architecture with three fully connected layers and two non-linearity functions (ReLU)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-09-06T05:38:38.166660900Z",
     "start_time": "2023-09-06T05:38:38.146660700Z"
    }
   },
   "outputs": [],
   "source": [
    "class Network(nn.Module):\n",
    "    def __init__(self, in_dim: int, out_dim: int):\n",
    "        \"\"\"Initialization.\"\"\"\n",
    "        super(Network, self).__init__()\n",
    "\n",
    "        self.layers = nn.Sequential(\n",
    "            nn.Linear(in_dim, 128), \n",
    "            nn.ReLU(),\n",
    "            nn.Linear(128, 128), \n",
    "            nn.ReLU(), \n",
    "            nn.Linear(128, out_dim)\n",
    "        )\n",
    "\n",
    "    def forward(self, x: torch.Tensor) -> torch.Tensor:\n",
    "        \"\"\"Forward method implementation.\"\"\"\n",
    "        return self.layers(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## DQN Agent + N-step learning Agent\n",
    "\n",
    "Here is a summary of DQNAgent class.\n",
    "\n",
    "| Method           | Note                                                 |\n",
    "| ---              | ---                                                  |\n",
    "|select_action     | select an action from the input state.               |\n",
    "|step              | take an action and return the response of the env.   |\n",
    "|compute_dqn_loss  | return dqn loss.                                     |\n",
    "|update_model      | update the model by gradient descent.                |\n",
    "|target_hard_update| hard update from the local model to the target model.|\n",
    "|train             | train the agent during num_frames.                   |\n",
    "|test              | test the agent (1 episode).                          |\n",
    "|plot              | plot the training progresses.                        |\n",
    "\n",
    "We use two buffers: `memory` and `memory_n` for 1-step transitions and n-step transitions respectively. It guarantees that any paired 1-step and n-step transitions have the same indices (See `step` method for more details). Due to the reason, we can sample pairs of transitions from the two buffers once we have indices for samples.\n",
    "\n",
    "```python\n",
    "    def update_model(self) -> torch.Tensor:\n",
    "        ...\n",
    "        samples = self.memory.sample_batch()\n",
    "        indices = samples[\"indices\"]\n",
    "        ...\n",
    "        \n",
    "        # N-step Learning loss\n",
    "        if self.use_n_step:\n",
    "            samples = self.memory_n.sample_batch_from_idxs(indices)\n",
    "            ...\n",
    "```\n",
    "\n",
    "One thing to note that  we are gonna combine 1-step loss and n-step loss so as to control high-variance / high-bias trade-off.\n",
    "\n",
    "(Search the comments with *N-step Leaning* to see any difference from DQN.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-09-06T05:38:38.203661200Z",
     "start_time": "2023-09-06T05:38:38.160660800Z"
    }
   },
   "outputs": [],
   "source": [
    "class DQNAgent:\n",
    "    \"\"\"DQN Agent interacting with environment.\n",
    "    \n",
    "    Attribute:\n",
    "        env (gym.Env): openAI Gym environment\n",
    "        memory (ReplayBuffer): replay memory to store transitions\n",
    "        batch_size (int): batch size for sampling\n",
    "        epsilon (float): parameter for epsilon greedy policy\n",
    "        epsilon_decay (float): step size to decrease epsilon\n",
    "        max_epsilon (float): max value of epsilon\n",
    "        min_epsilon (float): min value of epsilon\n",
    "        target_update (int): period for target model's hard update\n",
    "        gamma (float): discount factor\n",
    "        dqn (Network): model to train and select actions\n",
    "        dqn_target (Network): target model to update\n",
    "        optimizer (torch.optim): optimizer for training dqn\n",
    "        transition (list): transition information including \n",
    "                           state, action, reward, next_state, done\n",
    "        use_n_step (bool): whether to use n_step memory\n",
    "        n_step (int): step number to calculate n-step td error\n",
    "        memory_n (ReplayBuffer): n-step replay buffer\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(\n",
    "        self, \n",
    "        env: gym.Env,\n",
    "        memory_size: int,\n",
    "        batch_size: int,\n",
    "        target_update: int,\n",
    "        epsilon_decay: float,\n",
    "        seed: int,\n",
    "        max_epsilon: float = 1.0,\n",
    "        min_epsilon: float = 0.1,\n",
    "        gamma: float = 0.99,\n",
    "        # N-step Learning\n",
    "        n_step: int = 3,\n",
    "    ):\n",
    "        \"\"\"Initialization.\n",
    "        \n",
    "        Args:\n",
    "            env (gym.Env): openAI Gym environment\n",
    "            memory_size (int): length of memory\n",
    "            batch_size (int): batch size for sampling\n",
    "            target_update (int): period for target model's hard update\n",
    "            epsilon_decay (float): step size to decrease epsilon\n",
    "            lr (float): learning rate\n",
    "            max_epsilon (float): max value of epsilon\n",
    "            min_epsilon (float): min value of epsilon\n",
    "            gamma (float): discount factor\n",
    "            n_step (int): step number to calculate n-step td error\n",
    "        \"\"\"\n",
    "        obs_dim = env.observation_space.shape[0]\n",
    "        action_dim = env.action_space.n\n",
    "        \n",
    "        self.env = env\n",
    "        self.batch_size = batch_size\n",
    "        self.epsilon = max_epsilon\n",
    "        self.epsilon_decay = epsilon_decay\n",
    "        self.seed = seed\n",
    "        self.max_epsilon = max_epsilon\n",
    "        self.min_epsilon = min_epsilon\n",
    "        self.target_update = target_update\n",
    "        self.gamma = gamma\n",
    "        \n",
    "        # memory for 1-step Learning\n",
    "        self.memory = ReplayBuffer(\n",
    "            obs_dim, memory_size, batch_size, n_step=1\n",
    "        )\n",
    "        \n",
    "        # memory for N-step Learning\n",
    "        # 这句话在代码质量如此高的 Rainbow 中显得格格不入\n",
    "        self.use_n_step = True if n_step > 1 else False  \n",
    "        if self.use_n_step:\n",
    "            self.n_step = n_step\n",
    "            self.memory_n = ReplayBuffer(\n",
    "                obs_dim, memory_size, batch_size, n_step=n_step, gamma=gamma\n",
    "            )\n",
    "        \n",
    "        # device: cpu / gpu\n",
    "        self.device = torch.device(\n",
    "            \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
    "        )\n",
    "        print(self.device)\n",
    "\n",
    "        # networks: dqn, dqn_target\n",
    "        self.dqn = Network(obs_dim, action_dim).to(self.device)\n",
    "        self.dqn_target = Network(obs_dim, action_dim).to(self.device)\n",
    "        self.dqn_target.load_state_dict(self.dqn.state_dict())\n",
    "        self.dqn_target.eval()\n",
    "        \n",
    "        # optimizer\n",
    "        self.optimizer = optim.Adam(self.dqn.parameters())\n",
    "\n",
    "        # transition to store in memory\n",
    "        self.transition = list()\n",
    "        \n",
    "        # mode: train / test\n",
    "        self.is_test = False\n",
    "\n",
    "    def select_action(self, state: np.ndarray) -> np.ndarray:\n",
    "        \"\"\"Select an action from the input state.\"\"\"\n",
    "        # epsilon greedy policy\n",
    "        if self.epsilon > np.random.random():\n",
    "            selected_action = self.env.action_space.sample()\n",
    "        else:\n",
    "            selected_action = self.dqn(\n",
    "                torch.FloatTensor(state).to(self.device)\n",
    "            ).argmax()\n",
    "            selected_action = selected_action.detach().cpu().numpy()\n",
    "        \n",
    "        if not self.is_test:\n",
    "            self.transition = [state, selected_action]\n",
    "        \n",
    "        return selected_action\n",
    "\n",
    "    def step(self, action: np.ndarray) -> Tuple[np.ndarray, np.float64, bool]:\n",
    "        \"\"\"Take an action and return the response of the env.\"\"\"\n",
    "        next_state, reward, terminated, truncated, _ = self.env.step(action)\n",
    "        done = terminated or truncated\n",
    "        \n",
    "        if not self.is_test:\n",
    "            self.transition += [reward, next_state, done]\n",
    "            \n",
    "            # N-step transition\n",
    "            if self.use_n_step:\n",
    "                one_step_transition = self.memory_n.store(*self.transition)\n",
    "            # 1-step transition\n",
    "            else:\n",
    "                one_step_transition = self.transition\n",
    "\n",
    "            # add a single step transition\n",
    "            if one_step_transition:\n",
    "                self.memory.store(*one_step_transition)\n",
    "    \n",
    "        return next_state, reward, done\n",
    "\n",
    "    def update_model(self) -> torch.Tensor:\n",
    "        \"\"\"Update the model by gradient descent.\"\"\"\n",
    "        samples = self.memory.sample_batch()\n",
    "        indices = samples[\"indices\"]\n",
    "        loss = self._compute_dqn_loss(samples, self.gamma)\n",
    "        \n",
    "        # N-step Learning loss\n",
    "        # we are gonna combine 1-step loss and n-step loss so as to\n",
    "        # prevent high-variance.\n",
    "        if self.use_n_step:\n",
    "            samples = self.memory_n.sample_batch_from_idxs(indices)\n",
    "            gamma = self.gamma ** self.n_step\n",
    "            n_loss = self._compute_dqn_loss(samples, gamma)\n",
    "            loss += n_loss\n",
    "\n",
    "        self.optimizer.zero_grad()\n",
    "        loss.backward()\n",
    "        self.optimizer.step()\n",
    "\n",
    "        return loss.item()\n",
    "        \n",
    "    def train(self, num_frames: int, plotting_interval: int = 200):\n",
    "        \"\"\"Train the agent.\"\"\"\n",
    "        self.is_test = False\n",
    "        \n",
    "        state, _ = self.env.reset(seed=self.seed)\n",
    "        update_cnt = 0\n",
    "        epsilons = []\n",
    "        losses = []\n",
    "        scores = []\n",
    "        score = 0\n",
    "\n",
    "        for frame_idx in range(1, num_frames + 1):\n",
    "            action = self.select_action(state)\n",
    "            next_state, reward, done = self.step(action)\n",
    "\n",
    "            state = next_state\n",
    "            score += reward\n",
    "\n",
    "            # if episode ends\n",
    "            if done:\n",
    "                state, _ = self.env.reset(seed=self.seed)\n",
    "                scores.append(score)\n",
    "                score = 0\n",
    "\n",
    "            # if training is ready\n",
    "            if len(self.memory) >= self.batch_size:\n",
    "                loss = self.update_model()\n",
    "                losses.append(loss)\n",
    "                update_cnt += 1\n",
    "                \n",
    "                # linearly decrease epsilon\n",
    "                self.epsilon = max(\n",
    "                    self.min_epsilon, self.epsilon - (\n",
    "                        self.max_epsilon - self.min_epsilon\n",
    "                    ) * self.epsilon_decay\n",
    "                )\n",
    "                epsilons.append(self.epsilon)\n",
    "                \n",
    "                # if hard update is needed\n",
    "                if update_cnt % self.target_update == 0:\n",
    "                    self._target_hard_update()\n",
    "\n",
    "            # plotting\n",
    "            if frame_idx % plotting_interval == 0:\n",
    "                self._plot(frame_idx, scores, losses, epsilons)\n",
    "                \n",
    "        self.env.close()\n",
    "                \n",
    "    def test(self, video_folder: str) -> None:\n",
    "        \"\"\"Test the agent.\"\"\"\n",
    "        self.is_test = True\n",
    "        \n",
    "        # for recording a video\n",
    "        naive_env = self.env\n",
    "        self.env = gym.wrappers.RecordVideo(self.env, video_folder=video_folder)\n",
    "        \n",
    "        state, _ = self.env.reset(seed=self.seed)\n",
    "        done = False\n",
    "        score = 0\n",
    "        \n",
    "        while not done:\n",
    "            action = self.select_action(state)\n",
    "            next_state, reward, done = self.step(action)\n",
    "\n",
    "            state = next_state\n",
    "            score += reward\n",
    "        \n",
    "        print(\"score: \", score)\n",
    "        self.env.close()\n",
    "        \n",
    "        # reset\n",
    "        self.env = naive_env\n",
    "        \n",
    "    def _compute_dqn_loss(\n",
    "        self, \n",
    "        samples: Dict[str, np.ndarray], \n",
    "        gamma: float\n",
    "    ) -> torch.Tensor:\n",
    "        \"\"\"Return dqn loss.\"\"\"\n",
    "        device = self.device  # for shortening the following lines\n",
    "        state = torch.FloatTensor(samples[\"obs\"]).to(device)\n",
    "        next_state = torch.FloatTensor(samples[\"next_obs\"]).to(device)\n",
    "        action = torch.LongTensor(samples[\"acts\"].reshape(-1, 1)).to(device)\n",
    "        reward = torch.FloatTensor(samples[\"rews\"].reshape(-1, 1)).to(device)\n",
    "        done = torch.FloatTensor(samples[\"done\"].reshape(-1, 1)).to(device)\n",
    "\n",
    "        # G_t   = r + gamma * v(s_{t+1})  if state != Terminal\n",
    "        #       = r                       otherwise\n",
    "        curr_q_value = self.dqn(state).gather(1, action)\n",
    "        next_q_value = self.dqn_target(next_state).max(\n",
    "            dim=1, keepdim=True\n",
    "        )[0].detach()\n",
    "        mask = 1 - done\n",
    "        target = (reward + gamma * next_q_value * mask).to(self.device)\n",
    "\n",
    "        # calculate dqn loss\n",
    "        loss = F.smooth_l1_loss(curr_q_value, target)\n",
    "\n",
    "        return loss\n",
    "\n",
    "    def _target_hard_update(self):\n",
    "        \"\"\"Hard update: target <- local.\"\"\"\n",
    "        self.dqn_target.load_state_dict(self.dqn.state_dict())\n",
    "                \n",
    "    def _plot(\n",
    "        self, \n",
    "        frame_idx: int, \n",
    "        scores: List[float], \n",
    "        losses: List[float], \n",
    "        epsilons: List[float],\n",
    "    ):\n",
    "        \"\"\"Plot the training progresses.\"\"\"\n",
    "        clear_output(True)\n",
    "        plt.figure(figsize=(20, 5))\n",
    "        plt.subplot(131)\n",
    "        plt.title('frame %s. score: %s' % (frame_idx, np.mean(scores[-10:])))\n",
    "        plt.plot(scores)\n",
    "        plt.subplot(132)\n",
    "        plt.title('loss')\n",
    "        plt.plot(losses)\n",
    "        plt.subplot(133)\n",
    "        plt.title('epsilons')\n",
    "        plt.plot(epsilons)\n",
    "        plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Environment\n",
    "\n",
    "You can see the [code](https://github.com/Farama-Foundation/Gymnasium/blob/main/gymnasium/envs/classic_control/cartpole.py) and [configurations](https://github.com/Farama-Foundation/Gymnasium/blob/main/gymnasium/envs/classic_control/cartpole.py#L91) of CartPole-v1 from Farama Gymnasium's repository."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-09-06T05:38:38.212682900Z",
     "start_time": "2023-09-06T05:38:38.192662700Z"
    }
   },
   "outputs": [],
   "source": [
    "# environment\n",
    "env = gym.make(\"CartPole-v1\", max_episode_steps=200, render_mode=\"rgb_array\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Set random seed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-09-06T05:38:38.227659800Z",
     "start_time": "2023-09-06T05:38:38.206660900Z"
    }
   },
   "outputs": [],
   "source": [
    "seed = 777\n",
    "\n",
    "def seed_torch(seed):\n",
    "    torch.manual_seed(seed)\n",
    "    if torch.backends.cudnn.enabled:\n",
    "        torch.cuda.manual_seed(seed)\n",
    "        torch.backends.cudnn.benchmark = False\n",
    "        torch.backends.cudnn.deterministic = True\n",
    "\n",
    "np.random.seed(seed)\n",
    "seed_torch(seed)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Initialize"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-09-06T05:38:38.256660Z",
     "start_time": "2023-09-06T05:38:38.222661200Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cuda\n"
     ]
    }
   ],
   "source": [
    "# parameters\n",
    "num_frames = 10000\n",
    "memory_size = 2000\n",
    "batch_size = 32\n",
    "target_update = 100\n",
    "epsilon_decay = 1 / 2000\n",
    "\n",
    "# train\n",
    "agent = DQNAgent(env, memory_size, batch_size, target_update, epsilon_decay, seed)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Train"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": "<Figure size 2000x500 with 3 Axes>",
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "agent.train(num_frames)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Test\n",
    "\n",
    "Run the trained agent (1 episode)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-09-06T05:39:22.942310200Z",
     "start_time": "2023-09-06T05:39:21.955552500Z"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\18213\\anaconda3\\envs\\Rainbow\\lib\\site-packages\\gymnasium\\wrappers\\record_video.py:87: UserWarning: \u001B[33mWARN: Overwriting existing videos at C:\\Users\\18213\\Source\\Rainbow Reading Notes\\videos\\n_step_learning folder (try specifying a different `video_folder` for the `RecordVideo` wrapper if this is not desired)\u001B[0m\n",
      "  logger.warn(\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Moviepy - Building video C:\\Users\\18213\\Source\\Rainbow Reading Notes\\videos\\n_step_learning\\rl-video-episode-0.mp4.\n",
      "Moviepy - Writing video C:\\Users\\18213\\Source\\Rainbow Reading Notes\\videos\\n_step_learning\\rl-video-episode-0.mp4\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                              \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Moviepy - Done !\n",
      "Moviepy - video ready C:\\Users\\18213\\Source\\Rainbow Reading Notes\\videos\\n_step_learning\\rl-video-episode-0.mp4\n",
      "score:  200.0\n"
     ]
    }
   ],
   "source": [
    "video_folder=\"videos/n_step_learning\"\n",
    "agent.test(video_folder=video_folder)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Render"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-09-06T05:39:22.943293Z",
     "start_time": "2023-09-06T05:39:22.916294200Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": "<IPython.core.display.HTML object>",
      "text/html": "\n        <video width=\"320\" height=\"240\" alt=\"test\" controls>\n        <source src=\"data:video/mp4;base64,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\" type=\"video/mp4\"/>\n        </video>\n        "
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Played: videos/n_step_learning\\rl-video-episode-0.mp4\n"
     ]
    }
   ],
   "source": [
    "import base64\n",
    "import glob\n",
    "import io\n",
    "import os\n",
    "\n",
    "from IPython.display import HTML, display\n",
    "\n",
    "\n",
    "def ipython_show_video(path: str) -> None:\n",
    "    \"\"\"Show a video at `path` within IPython Notebook.\"\"\"\n",
    "    if not os.path.isfile(path):\n",
    "        raise NameError(\"Cannot access: {}\".format(path))\n",
    "\n",
    "    video = io.open(path, \"r+b\").read()\n",
    "    encoded = base64.b64encode(video)\n",
    "\n",
    "    display(HTML(\n",
    "        data=\"\"\"\n",
    "        <video width=\"320\" height=\"240\" alt=\"test\" controls>\n",
    "        <source src=\"data:video/mp4;base64,{0}\" type=\"video/mp4\"/>\n",
    "        </video>\n",
    "        \"\"\".format(encoded.decode(\"ascii\"))\n",
    "    ))\n",
    "\n",
    "\n",
    "def show_latest_video(video_folder: str) -> str:\n",
    "    \"\"\"Show the most recently recorded video from video folder.\"\"\"\n",
    "    list_of_files = glob.glob(os.path.join(video_folder, \"*.mp4\"))\n",
    "    latest_file = max(list_of_files, key=os.path.getctime)\n",
    "    ipython_show_video(latest_file)\n",
    "    return latest_file\n",
    "\n",
    "\n",
    "latest_file = show_latest_video(video_folder=video_folder)\n",
    "print(\"Played:\", latest_file)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "name": "python3",
   "language": "python",
   "display_name": "Python 3 (ipykernel)"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
